import axios from "axios";

/**
 * 微信API服务
 * 封装了与微信注入工具交互的API
 */
class WeChatApiService {
  /**
   * 构造函数
   * @param {number} port - 注入工具的端口号
   */
  constructor(port = 8989) {
    this.port = port;
    // 不预先创建axios实例，而是在每次请求时根据当前端口创建
  }

  /**
   * 设置端口号
   * @param {number} port - 新的端口号
   */
  setPort(port) {
    this.port = port;
  }

  /**
   * 获取API基础URL
   * @returns {string} - API基础URL
   */
  getBaseURL() {
    return `http://127.0.0.1:${this.port}/api`;
  }

  /**
   * 发送API请求
   * @param {Object} data - 请求数据
   * @returns {Promise<Object>} - 响应数据
   */
  async request(data) {
    try {
      // 每次请求时使用当前端口构建URL
      const url = this.getBaseURL();

      // 记录请求日志
      const logMessage = `API请求: ${url} - 数据: ${JSON.stringify(data)}`;
      console.log(logMessage);

      // 如果在渲染进程中，尝试使用 logStore 记录日志
      if (typeof window !== "undefined" && window.logToStore) {
        window.logToStore(logMessage);
      } else if (this._logToConsole) {
        // 如果在主进程中，使用主进程日志函数
        this._logToConsole(logMessage);
      }

      const response = await axios.post(url, data, {
        headers: {
          "Content-Type": "application/json",
        },
      });

      // 记录响应日志
      const responseLog = `API响应: ${JSON.stringify(response.data)}`;
      console.log(responseLog);

      // 如果在渲染进程中，尝试使用 logStore 记录日志
      if (typeof window !== "undefined" && window.logToStore) {
        window.logToStore(responseLog);
      } else if (this._logToConsole) {
        // 如果在主进程中，使用主进程日志函数
        this._logToConsole(responseLog);
      }

      return response.data;
    } catch (error) {
      // 记录错误日志
      const errorLog = `API请求失败: ${error.message}`;
      console.error(errorLog);

      // 如果在渲染进程中，尝试使用 logStore 记录日志
      if (typeof window !== "undefined" && window.logToStore) {
        window.logToStore(errorLog);
      } else if (this._logToConsole) {
        // 如果在主进程中，使用主进程日志函数
        this._logToConsole(errorLog);
      }

      throw error;
    }
  }

  /**
   * 获取登录状态
   * @returns {Promise<Object>} - 登录状态信息
   */
  async getLoginStatus() {
    try {
      // 使用 type: 1 获取登录状态
      const result = await this.request({
        type: 1, // type 是数字 1，不是字符串
      });
      return result;
    } catch (error) {
      console.error("获取登录状态失败:", error);
      return {
        errno: -1,
        errmsg: error.message,
        data: { status: 0 },
      };
    }
  }

  /**
   * 获取用户信息
   * @returns {Promise<Object>} - 用户信息
   */
  async getUserInfo() {
    try {
      // 使用 type: 2 获取用户信息
      const result = await this.request({
        type: 2, // type 是数字 2，不是字符串
      });
      return result;
    } catch (error) {
      console.error("获取用户信息失败:", error);
      return {
        errno: -1,
        errmsg: error.message,
        data: null,
      };
    }
  }

  /**
   * 获取好友列表
   * @returns {Promise<Object>} - 好友列表
   */
  async getFriendList() {
    try {
      // 使用 type: 3 获取好友列表
      const result = await this.request({
        type: 3, // type 是数字 3，不是字符串
      });
      return result;
    } catch (error) {
      console.error("获取好友列表失败:", error);
      return {
        errno: -1,
        errmsg: error.message,
        data: [],
      };
    }
  }

  /**
   * 获取群组列表
   * @returns {Promise<Object>} - 群组列表
   */
  async getGroupList() {
    try {
      // 使用 type: 4 获取群组列表
      const result = await this.request({
        type: 4, // type 是数字 4，不是字符串
      });
      return result;
    } catch (error) {
      console.error("获取群组列表失败:", error);
      return {
        errno: -1,
        errmsg: error.message,
        data: [],
      };
    }
  }

  /**
   * 获取公众号列表
   * @returns {Promise<Object>} - 公众号列表
   */
  async getPublicAccountList() {
    try {
      // 使用 type: 5 获取公众号列表
      const result = await this.request({
        type: 5, // type 是数字 5，不是字符串
      });
      return result;
    } catch (error) {
      console.error("获取公众号列表失败:", error);
      return {
        errno: -1,
        errmsg: error.message,
        data: [],
      };
    }
  }

  /**
   * 获取群成员列表
   * @param {string} groupId - 群组ID
   * @returns {Promise<Object>} - 群成员列表
   */
  async getGroupMembers(groupId) {
    try {
      if (!groupId) {
        throw new Error("群组ID不能为空");
      }

      // 使用 type: 6 获取群成员列表
      const result = await this.request({
        type: 6, // type 是数字 6，不是字符串
        group_id: groupId,
      });
      return result;
    } catch (error) {
      console.error("获取群成员列表失败:", error);
      return {
        errno: -1,
        errmsg: error.message,
        data: [],
      };
    }
  }

  /**
   * 发送文本消息
   * @param {string} wxId - 接收者微信ID
   * @param {string} content - 消息内容
   * @returns {Promise<Object>} - 发送结果
   */
  async sendTextMessage(wxId, content) {
    try {
      if (!wxId) {
        throw new Error("接收者微信ID不能为空");
      }
      if (!content) {
        throw new Error("消息内容不能为空");
      }

      // 使用 type: 7 发送文本消息
      const result = await this.request({
        type: 7, // type 是数字 7，不是字符串
        to_wxid: wxId,
        content: content,
      });
      return result;
    } catch (error) {
      console.error("发送文本消息失败:", error);
      return {
        errno: -1,
        errmsg: error.message,
      };
    }
  }

  /**
   * 发送图片消息
   * @param {string} wxId - 接收者微信ID
   * @param {string} path - 图片路径
   * @returns {Promise<Object>} - 发送结果
   */
  async sendImageMessage(wxId, path) {
    try {
      if (!wxId) {
        throw new Error("接收者微信ID不能为空");
      }
      if (!path) {
        throw new Error("图片路径不能为空");
      }

      // 使用 type: 8 发送图片消息
      const result = await this.request({
        type: 8, // type 是数字 8，不是字符串
        to_wxid: wxId,
        file_path: path,
      });
      return result;
    } catch (error) {
      console.error("发送图片消息失败:", error);
      return {
        errno: -1,
        errmsg: error.message,
      };
    }
  }

  /**
   * 发送文件消息
   * @param {string} wxId - 接收者微信ID
   * @param {string} path - 文件路径
   * @returns {Promise<Object>} - 发送结果
   */
  async sendFileMessage(wxId, path) {
    try {
      if (!wxId) {
        throw new Error("接收者微信ID不能为空");
      }
      if (!path) {
        throw new Error("文件路径不能为空");
      }

      // 使用 type: 9 发送文件消息
      const result = await this.request({
        type: 9, // type 是数字 9，不是字符串
        to_wxid: wxId,
        file_path: path,
      });
      return result;
    } catch (error) {
      console.error("发送文件消息失败:", error);
      return {
        errno: -1,
        errmsg: error.message,
      };
    }
  }

  /**
   * 发送群消息并@指定成员
   * @param {string} groupId - 群组ID
   * @param {string} content - 消息内容
   * @param {Array<string>} atList - 要@的成员ID列表
   * @returns {Promise<Object>} - 发送结果
   */
  async sendGroupMessageWithAt(groupId, content, atList) {
    try {
      if (!groupId) {
        throw new Error("群组ID不能为空");
      }
      if (!content) {
        throw new Error("消息内容不能为空");
      }
      if (!Array.isArray(atList) || atList.length === 0) {
        throw new Error("@列表不能为空");
      }

      // 使用 type: 10 发送群消息并@指定成员
      const result = await this.request({
        type: 10, // type 是数字 10，不是字符串
        group_wxid: groupId,
        content: content,
        at_list: atList,
      });
      return result;
    } catch (error) {
      console.error("发送群消息并@指定成员失败:", error);
      return {
        errno: -1,
        errmsg: error.message,
      };
    }
  }

  /**
   * 发送群消息并@所有人
   * @param {string} groupId - 群组ID
   * @param {string} content - 消息内容
   * @returns {Promise<Object>} - 发送结果
   */
  async sendGroupMessageAtAll(groupId, content) {
    try {
      if (!groupId) {
        throw new Error("群组ID不能为空");
      }
      if (!content) {
        throw new Error("消息内容不能为空");
      }

      // 使用 type: 11 发送群消息并@所有人
      const result = await this.request({
        type: 11, // type 是数字 11，不是字符串
        group_wxid: groupId,
        content: content,
      });
      return result;
    } catch (error) {
      console.error("发送群消息并@所有人失败:", error);
      return {
        errno: -1,
        errmsg: error.message,
      };
    }
  }
}

/**
 * 消息监听服务
 * 用于监听微信消息
 */
class MessageListenerService {
  /**
   * 构造函数
   * @param {number} port - 消息监听端口
   * @param {Function} messageCallback - 消息回调函数
   */
  constructor(port = 9000, messageCallback = null) {
    this.port = port;
    this.messageCallback = messageCallback;
    this.isListening = false;

    // 设置消息接收事件监听（仅在渲染进程中）
    if (typeof window !== "undefined" && window.electronAPI) {
      window.addEventListener("message-received", (event) => {
        if (this.messageCallback && this.isListening) {
          this.handleMessage(event.detail);
        }
      });
    }
  }

  /**
   * 设置端口号
   * @param {number} port - 新的端口号
   */
  setPort(port) {
    this.port = port;
    console.log(`消息监听服务: 端口已更新为 ${port}`);

    // 如果在主进程中，使用主进程日志函数
    if (this._logToConsole) {
      this._logToConsole(`消息监听服务: 端口已更新为 ${port}`);
    }
  }

  /**
   * 设置消息回调函数
   * @param {Function} callback - 消息回调函数
   */
  setMessageCallback(callback) {
    this.messageCallback = callback;
    console.log("消息监听服务: 回调函数已设置");

    // 如果在主进程中，使用主进程日志函数
    if (this._logToConsole) {
      this._logToConsole("消息监听服务: 回调函数已设置");
    }
  }

  /**
   * 启动消息监听服务
   * @returns {Promise<boolean>} - 是否成功启动
   */
  async startServer() {
    try {
      console.log(`尝试启动消息监听服务，端口: ${this.port}`);

      // 如果在主进程中，使用主进程日志函数
      if (this._logToConsole) {
        this._logToConsole(`尝试启动消息监听服务，端口: ${this.port}`);
      }

      // 检查是否在渲染进程中
      if (typeof window !== "undefined" && window.electronAPI) {
        // 通过 IPC 请求主进程启动监听服务
        const result = await window.electronAPI.startListening(this.port);

        if (result && result.success) {
          this.isListening = true;
          console.log(`消息监听服务已启动，端口: ${this.port}`);

          // 如果在主进程中，使用主进程日志函数
          if (this._logToConsole) {
            this._logToConsole(`消息监听服务已启动，端口: ${this.port}`);
          }

          return true;
        } else {
          const errorMsg = `消息监听服务启动失败: ${
            result ? result.error : "未知错误"
          }`;
          console.error(errorMsg);

          // 如果在主进程中，使用主进程日志函数
          if (this._logToConsole) {
            this._logToConsole(errorMsg);
          }

          return false;
        }
      } else if (typeof global !== "undefined") {
        // 在主进程中，直接返回成功
        // 注意：在主进程中，消息监听服务应该由 background.js 直接管理
        this.isListening = true;
        console.log(`消息监听服务已在主进程中标记为启动，端口: ${this.port}`);

        // 如果在主进程中，使用主进程日志函数
        if (this._logToConsole) {
          this._logToConsole(
            `消息监听服务已在主进程中标记为启动，端口: ${this.port}`
          );
        }

        return true;
      } else {
        const errorMsg = "消息监听服务: 无法确定运行环境";
        console.error(errorMsg);

        // 如果在主进程中，使用主进程日志函数
        if (this._logToConsole) {
          this._logToConsole(errorMsg);
        }

        return false;
      }
    } catch (error) {
      const errorMsg = `启动消息监听服务时出错: ${error.message}`;
      console.error(errorMsg);

      // 如果在主进程中，使用主进程日志函数
      if (this._logToConsole) {
        this._logToConsole(errorMsg);
      }

      return false;
    }
  }

  /**
   * 停止消息监听服务
   * @returns {Promise<boolean>} - 是否成功停止
   */
  async stopServer() {
    try {
      if (!this.isListening) {
        console.log("消息监听服务: 服务未启动，无需停止");

        // 如果在主进程中，使用主进程日志函数
        if (this._logToConsole) {
          this._logToConsole("消息监听服务: 服务未启动，无需停止");
        }

        return true;
      }

      // 检查是否在渲染进程中
      if (typeof window !== "undefined" && window.electronAPI) {
        // 通过 IPC 请求主进程停止监听服务
        const result = await window.electronAPI.stopListening();

        if (result && result.success) {
          this.isListening = false;
          console.log("消息监听服务已停止");

          // 如果在主进程中，使用主进程日志函数
          if (this._logToConsole) {
            this._logToConsole("消息监听服务已停止");
          }

          return true;
        } else {
          const errorMsg = `消息监听服务停止失败: ${
            result ? result.error : "未知错误"
          }`;
          console.error(errorMsg);

          // 如果在主进程中，使用主进程日志函数
          if (this._logToConsole) {
            this._logToConsole(errorMsg);
          }

          return false;
        }
      } else if (typeof global !== "undefined") {
        // 在主进程中，直接返回成功
        this.isListening = false;
        console.log("消息监听服务已在主进程中标记为停止");

        // 如果在主进程中，使用主进程日志函数
        if (this._logToConsole) {
          this._logToConsole("消息监听服务已在主进程中标记为停止");
        }

        return true;
      } else {
        const errorMsg = "消息监听服务: 无法确定运行环境";
        console.error(errorMsg);

        // 如果在主进程中，使用主进程日志函数
        if (this._logToConsole) {
          this._logToConsole(errorMsg);
        }

        return false;
      }
    } catch (error) {
      const errorMsg = `停止消息监听服务时出错: ${error.message}`;
      console.error(errorMsg);

      // 如果在主进程中，使用主进程日志函数
      if (this._logToConsole) {
        this._logToConsole(errorMsg);
      }

      return false;
    }
  }

  /**
   * 处理接收到的消息
   * @param {Object|string} message - 接收到的消息
   */
  handleMessage(message) {
    try {
      // 确保我们有一个回调函数
      if (!this.messageCallback) {
        console.warn("消息监听器: 没有设置消息回调函数");

        // 如果在主进程中，使用主进程日志函数
        if (this._logToConsole) {
          this._logToConsole("消息监听器: 没有设置消息回调函数");
        }

        return;
      }

      // 尝试解析消息（如果它是字符串）
      let parsedMessage = message;
      if (typeof message === "string") {
        try {
          parsedMessage = JSON.parse(message);
        } catch (e) {
          // 如果不是有效的 JSON，保持原样
          console.log("消息监听器: 消息不是有效的 JSON 格式，按原样处理");

          // 如果在主进程中，使用主进程日志函数
          if (this._logToConsole) {
            this._logToConsole(
              "消息监听器: 消息不是有效的 JSON 格式，按原样处理"
            );
          }
        }
      }

      // 格式化消息对象
      let formattedMessage = parsedMessage;

      // 如果消息有特定格式，进行处理
      if (parsedMessage && typeof parsedMessage === "object") {
        // 根据消息类型添加额外信息
        if (parsedMessage.type === "chat") {
          formattedMessage = {
            type: "chat_message",
            from_user: parsedMessage.from_user || {
              wxid: "unknown",
              nickname: "未知用户",
            },
            to_user: parsedMessage.to_user || {
              wxid: "unknown",
              nickname: "未知用户",
            },
            content: parsedMessage.content || "",
            timestamp: parsedMessage.timestamp || Date.now(),
          };
        }
      }

      // 调用回调函数处理消息
      this.messageCallback(formattedMessage);
    } catch (error) {
      console.error("处理消息时出错:", error.message);

      // 如果在主进程中，使用主进程日志函数
      if (this._logToConsole) {
        this._logToConsole(`处理消息时出错: ${error.message}`);
      }

      // 尝试将错误消息传递给回调
      if (this.messageCallback) {
        this.messageCallback({
          type: "error",
          content: `处理消息时出错: ${error.message}`,
          timestamp: Date.now(),
        });
      }
    }
  }
}

// 创建单例实例
const wechatApi = new WeChatApiService();
const messageListener = new MessageListenerService();

export { WeChatApiService, MessageListenerService, wechatApi, messageListener };
